package com.ruoyi.mes.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.ruoyi.mes.domain.Device;
import com.ruoyi.mes.domain.DeviceParameter;
import com.ruoyi.mes.mapper.DeviceMapper;
import com.ruoyi.mes.mapper.DeviceParameterMapper;
import com.ruoyi.mes.vo.line.annualVo;
import com.ruoyi.mes.vo.line.dailyVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mes.mapper.ProductionLineMapper;
import com.ruoyi.mes.domain.ProductionLine;
import com.ruoyi.mes.service.IProductionLineService;

/**
 * 产线信息Service业务层处理
 * 
 * @author LongAndHao
 * @date 2024-11-04
 */
@Service
public class ProductionLineServiceImpl implements IProductionLineService 
{
    @Autowired
    private ProductionLineMapper productionLineMapper;
    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private DeviceParameterMapper deviceParameterMapper;

    /**
     * 查询产线信息
     * 
     * @param lineId 产线信息主键
     * @return 产线信息
     */
    @Override
    public ProductionLine selectProductionLineByLineId(Long lineId)
    {
        return productionLineMapper.selectProductionLineByLineId(lineId);
    }

    @Override
    public List<ProductionLine> selectProductionLineList(ProductionLine productionLine) {
        // 获取所有生产线数据
        List<ProductionLine> productionLines = productionLineMapper.selectProductionLineList(productionLine);

        // 过滤掉 lineId 为 500 的生产线
        List<ProductionLine> filteredProductionLines = productionLines.stream()
                .filter(pl -> pl.getLineId() == null || !pl.getLineId().equals(500L))
                .collect(Collectors.toList());

        // 遍历过滤后的生产线
        for (ProductionLine productionLine1 : filteredProductionLines) {
            Long jiepaiInt = 0L;  // 重置节拍总和

            // 根据当前生产线的 lineId 查询该生产线的设备
            List<Device> devices = deviceMapper.selectDeviceByLineId(productionLine1.getLineId());

            // 使用 Map 缓存设备的节拍参数，避免每次都查询数据库
            Map<Long, Long> deviceParameterMap = new HashMap<>();
            for (Device device : devices) {
                DeviceParameter deviceParameter = deviceParameterMapper.selectDeviceParameterByDeviceId(device.getId());
                if (deviceParameter != null && deviceParameter.getParameterValue() != null) {
                    deviceParameterMap.put(device.getId(), deviceParameter.getParameterValue());
                }
            }

            // 标志位：是否需要更新生产线状态
            boolean statusUpdated = false;

            // 遍历设备，计算 "节拍" 总和并检查是否需要更新生产线状态
            for (Device device : devices) {
                // 获取设备节拍参数
                Long jiepai = deviceParameterMap.get(device.getId());
                // 如果节拍值存在，累加到 jiepaiInt
                if (jiepai != null) {
                    try {
                        jiepaiInt += jiepai;
                    } catch (NumberFormatException e) {
                        System.err.println("Invalid number format for deviceId: " + device.getId());
                    }
                }

                // 如果设备状态不为0，标记生产线需要更新状态
                if (device.getAvailableStatus() != 0 && !statusUpdated) {
                    productionLine1.setStatus("1");
                    statusUpdated = true;
                }
            }

            // 设置生产线的 cycleTime
            productionLine1.setCycleTime(jiepaiInt);

            // 更新生产线数据
            productionLineMapper.updateProductionLine(productionLine1);
        }

        // 返回过滤后的生产线列表（不包含 lineId 为 500 的记录）
        return filteredProductionLines;
    }

    /**
     * 新增产线信息
     * 
     * @param productionLine 产线信息
     * @return 结果
     */
    @Override
    public int insertProductionLine(ProductionLine productionLine)
    {
        return productionLineMapper.insertProductionLine(productionLine);
    }

    /**
     * 修改产线信息
     * 
     * @param productionLine 产线信息
     * @return 结果
     */
    @Override
    public int updateProductionLine(ProductionLine productionLine)
    {
        return productionLineMapper.updateProductionLine(productionLine);
    }

    /**
     * 批量删除产线信息
     * 
     * @param lineIds 需要删除的产线信息主键
     * @return 结果
     */
    @Override
    public int deleteProductionLineByLineIds(Long[] lineIds)
    {
        return productionLineMapper.deleteProductionLineByLineIds(lineIds);
    }

    /**
     * 删除产线信息信息
     * 
     * @param lineId 产线信息主键
     * @return 结果
     */
    @Override
    public int deleteProductionLineByLineId(Long lineId)
    {
        return productionLineMapper.deleteProductionLineByLineId(lineId);
    }

    /**

     *
     * @return 结果
     */
    @Override
    public Long annualProduction() {
        // 获取所有生产线列表
        List<ProductionLine> productionLines = productionLineMapper.selectProductionLineList(new ProductionLine());

        // 定义总工作秒数：24小时/天 * 250天/年 * 3600秒/小时
        final long totalWorkingSeconds = 24L * 250 * 3600;

        // 初始化总年产量
        long totalAnnualProduction = 0L;

        // 遍历每条生产线，计算其年产量并累加
        for (ProductionLine productionLine : productionLines) {
            Long taktTime = productionLine.getCycleTime(); // 获取节拍时间（秒）

            if (taktTime != null && taktTime > 0) {
                // 计算当前生产线的年产量
                long annualProduction = totalWorkingSeconds / taktTime;

                // 累加到总年产量
                totalAnnualProduction += annualProduction;
            }
        }

        return totalAnnualProduction;
    }
    @Override
    public List<annualVo> annualProductionList() {
        List<annualVo> annualVos = new ArrayList<>();
        List<ProductionLine> productionLines = productionLineMapper.selectProductionLineList(new ProductionLine());

        // 定义总工作秒数：24小时/天 * 250天/年 * 3600秒/小时
        final long totalWorkingSeconds = 24L * 250 * 3600;

        for (ProductionLine productionLine : productionLines) {
            // 获取节拍时间（秒）
            Long taktTime = productionLine.getCycleTime();

            if (taktTime != null && taktTime > 0) {
                // 计算当前生产线的年产量
                long annualProduction = totalWorkingSeconds / taktTime;

                // 创建并设置 annualVo 对象
                annualVo vo = new annualVo();
                vo.setLine_id(productionLine.getLineId());
                vo.setLine_name(productionLine.getLineName());
                vo.setAnnual(annualProduction);

                // 添加到结果列表
                annualVos.add(vo);
            }
        }

        return annualVos;
    }
    @Override
    public List<dailyVo> dailyProductionList() {
        List<dailyVo> dailyVos = new ArrayList<>();
        List<ProductionLine> productionLines = productionLineMapper.selectProductionLineList(new ProductionLine());

        // 定义总工作秒数：24小时/天 * 3600秒/小时
        final long totalWorkingSecondsPerDay = 12L * 3600;

        for (ProductionLine productionLine : productionLines) {
            // 获取节拍时间（秒）
            Long taktTime = productionLine.getCycleTime();

            if (taktTime != null && taktTime > 0) {
                // 计算当前生产线的日产量
                long dailyProduction = totalWorkingSecondsPerDay / taktTime;

                // 创建并设置 dailyVo 对象
                dailyVo vo = new dailyVo();
                vo.setLine_id(productionLine.getLineId());
                vo.setLine_name(productionLine.getLineName());
                vo.setDaily(dailyProduction);

                // 添加到结果列表
                dailyVos.add(vo);
            } else {
                // 处理节拍时间为空或无效的情况（可以选择记录日志或者抛出异常）
                // 比如：log.warn("生产线 {} 的节拍时间无效或未配置", productionLine.getLineId());
                continue;
            }
        }

        return dailyVos;
    }
    @Override
    public Long dailyProduction() {
        // 获取所有生产线列表
        List<ProductionLine> productionLines = productionLineMapper.selectProductionLineList(new ProductionLine());

        // 定义总工作秒数：24小时/天 * 3600秒/小时
        final long totalWorkingSecondsPerDay = 12L * 3600;

        // 初始化总日产量
        long totalDailyProduction = 0L;

        // 遍历每条生产线，计算其日产量并累加
        for (ProductionLine productionLine : productionLines) {
            Long taktTime = productionLine.getCycleTime(); // 获取节拍时间（秒）

            if (taktTime != null && taktTime > 0) {
                // 计算当前生产线的日产量
                long dailyProduction = totalWorkingSecondsPerDay / taktTime;

                // 累加到总日产量
                totalDailyProduction += dailyProduction;
            } else {
                // 处理节拍时间为空或无效的情况（可选）
                // 例如，记录日志或抛出异常
                // 这里简单跳过
                continue;
            }
        }

        return totalDailyProduction;
    }
    @Override
    public List<ProductionLine> selectProductionLine0(ProductionLine productionLine){
        return productionLineMapper.selectProductionLine0(productionLine);
    }

}
